<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<HTML>
  <HEAD>
    <META name="generator" content=
    "HTML Tidy for Java (vers. 2009-12-01), see jtidy.sourceforge.net">
    <META http-equiv="Content-Type" content="text/html; charset=windows-1252">

    <TITLE>Regular Expressions</TITLE>
    <LINK rel="stylesheet" type="text/css" href="help/shared/DefaultStyle.css">
    <META name="generator" content="Microsoft FrontPage 4.0">
  </HEAD>

  <BODY>
    <H1><A name="Memory_Regular_Expressions"></A>Regular Expressions</H1>

    <P>Memory searches in Ghidra can use regular expressions for powerful and flexible searches.
    This feature uses Java's built-in regular expressions grammar, so the syntax is exactly the
    same as a regular expression for any standard Java application. Because of restrictions on how
    regular expressions are processed, regular expression searches can only be performed in the
    forward direction. Unlike standard string searches, case sensitivity and unicode options do not
    apply. The <I>Search Memory</I> window below shows a sample regular expression entered in the
    <I>Value</I> field.</P>



    <BLOCKQUOTE>  
    <BLOCKQUOTE>
    <TABLE border="0" width="80%">
      <TBODY>
        <TR>
          <TD align="left"><IMG border="0" src="images/SearchMemoryRegex.png" alt=""></TD>
        </TR>
      </TBODY>
    </TABLE>
	</BLOCKQUOTE>
    <H3>Examples</H3>

    <BLOCKQUOTE>
      <TABLE border="1" width="80%">
        <TBODY>
          <TR>
            <TD>
              <P><B>cafebabe</B></P>
            </TD>

            <TD>
              <P>Searches for the string "cafebabe"</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>\x30\x31</B></P>
            </TD>

            <TD>
              <P>Searches for the byte 0x30 followed by the byte 0x31</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>abc\n[^a]abc</B></P>
            </TD>

            <TD>
              <P>Searches for "abc" followed by LF, followed by any character other than a,
              followed by "abc"</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>[a-z]{1,5}.</B></P>
            </TD>

            <TD>
              <P>Searches for any letter in the range a-z occurring 1-5 times followed by any
              character</P>
            </TD>
          </TR>

          <TR>
            <TD>
              <P><B>\x50.{0,10}\x55</B></P>
            </TD>

            <TD>
              <P>Searches for 0x50 followed by 0-10 occurrences of any character, followed by
              0x55</P>
            </TD>
          </TR>
          
          <TR>
            <TD width="220">
              <P><B>(..[\x50-\x5f]\x00)\1{15}</B></P>
            </TD>

            <TD>
              <P>Matches 16 runs of an address, in a row, with the value <tt>0x005????</tt>, 
              where ?? can be any byte value; for example, 0x00512345</P>
            </TD>
          </TR>
          
        </TBODY>
      </TABLE>
    </BLOCKQUOTE>

    <H3><A name="Regex_Syntax"/>Regular Expression Syntax</H3>

    <BLOCKQUOTE>
      <P>The following is the full syntax for Java's regular expression grammar from Oracle's
      Pattern class javadoc (https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)</P>

      <BR>
      <TABLE border="0" cellpadding="1" cellspacing="0" summary=
      "Regular expression constructs, and what they match">
        <TBODY>
          <TR align="left">
            <TH bgcolor="#CCCCFF" align="left" id="construct">Construct</TH>

            <TH bgcolor="#CCCCFF" align="left" id="matches">Matches</TH>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Characters</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><I>x</I></TD>

            <TD headers="matches">The character <I>x</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\\</TT></TD>

            <TD headers="matches">The backslash character</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>n</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>n</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>nn</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>nn</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\0</TT><I>mnn</I></TD>

            <TD headers="matches">The character with octal value <TT>0</TT><I>mnn</I>
            (0&nbsp;<TT>&lt;=</TT>&nbsp;<I>m</I>&nbsp;<TT>&lt;=</TT>&nbsp;3,
            0&nbsp;<TT>&lt;=</TT>&nbsp;<I>n</I>&nbsp;<TT>&lt;=</TT>&nbsp;7)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\x</TT><I>hh</I></TD>

            <TD headers="matches">The character with
            hexadecimal&nbsp;value&nbsp;<TT>0x</TT><I>hh</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\u</TT><I>hhhh</I></TD>

            <TD headers="matches">The character with
            hexadecimal&nbsp;value&nbsp;<TT>0x</TT><I>hhhh</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="matches"><TT>\t</TT></TD>

            <TD headers="matches">The tab character (<TT>'\u0009'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\n</TT></TD>

            <TD headers="matches">The newline (line feed) character (<TT>'\u000A'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\r</TT></TD>

            <TD headers="matches">The carriage-return character (<TT>'\u000D'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\f</TT></TD>

            <TD headers="matches">The form-feed character (<TT>'\u000C'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\a</TT></TD>

            <TD headers="matches">The alert (bell) character (<TT>'\u0007'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\e</TT></TD>

            <TD headers="matches">The escape character (<TT>'\u001B'</TT>)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct characters"><TT>\c</TT><I>x</I></TD>

            <TD headers="matches">The control character corresponding to <I>x</I></TD>
          </TR>



          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Character classes</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[abc]</TT></TD>

            <TD headers="matches"><TT>a</TT>, <TT>b</TT>, or <TT>c</TT> (simple class)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[^abc]</TT></TD>

            <TD headers="matches">Any character except <TT>a</TT>, <TT>b</TT>, or <TT>c</TT>
            (negation)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-zA-Z]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT> or <TT>A</TT> through <TT>Z</TT>,
            inclusive (range)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-d[m-p]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>d</TT>, or <TT>m</TT> through <TT>p</TT>:
            <TT>[a-dm-p]</TT> (union)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[def]]</TT></TD>

            <TD headers="matches"><TT>d</TT>, <TT>e</TT>, or <TT>f</TT> (intersection)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[^bc]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT>, except for <TT>b</TT> and
            <TT>c</TT>: <TT>[ad-z]</TT> (subtraction)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct classes"><TT>[a-z&amp;&amp;[^m-p]]</TT></TD>

            <TD headers="matches"><TT>a</TT> through <TT>z</TT>, and not <TT>m</TT> through
            <TT>p</TT>: <TT>[a-lq-z]</TT> (subtraction)</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD><B>Predefined character classes</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef" align="left"><TT>.</TT></TD>

            <TD headers="matches">Any character (may or may not match line terminators)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\d</TT></TD>

            <TD headers="matches">A digit: <TT>[0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\D</TT></TD>

            <TD headers="matches">A non-digit: <TT>[^0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\s</TT></TD>

            <TD headers="matches">A whitespace character: <TT>[ \t\n\x0B\f\r]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\S</TT></TD>

            <TD headers="matches">A non-whitespace character: <TT>[^\s]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\w</TT></TD>

            <TD headers="matches">A word character: <TT>[a-zA-Z_0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct predef"><TT>\W</TT></TD>

            <TD headers="matches">A non-word character: <TT>[^\w]</TT></TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR>
            <TD align="left" colspan="2">
              <B>POSIX character classes&nbsp;(US-ASCII only)</B>
            </TD>

          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Lower}</TT></TD>

            <TD headers="matches">A lower-case alphabetic character: <TT>[a-z]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Upper}</TT></TD>

            <TD headers="matches">An upper-case alphabetic character:<TT>[A-Z]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{ASCII}</TT></TD>

            <TD headers="matches">All ASCII:<TT>[\x00-\x7F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Alpha}</TT></TD>

            <TD headers="matches">An alphabetic character:<TT>[\p{Lower}\p{Upper}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Digit}</TT></TD>

            <TD headers="matches">A decimal digit: <TT>[0-9]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Alnum}</TT></TD>

            <TD headers="matches">An alphanumeric character:<TT>[\p{Alpha}\p{Digit}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Punct}</TT></TD>

            <TD headers="matches">Punctuation: One of
            <TT>!"#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</TT></TD>
          </TR><!-- <tt>[\!"#\$%&'\(\)\*\+,\-\./:;\<=\>\?@\[\\\]\^_`\{\|\}~]</tt>
                    <tt>[\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E]</tt> -->

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Graph}</TT></TD>

            <TD headers="matches">A visible character: <TT>[\p{Alnum}\p{Punct}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Print}</TT></TD>

            <TD headers="matches">A printable character: <TT>[\p{Graph}]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Blank}</TT></TD>

            <TD headers="matches">A space or a tab: <TT>[ \t]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Cntrl}</TT></TD>

            <TD headers="matches">A control character: <TT>[\x00-\x1F\x7F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{XDigit}</TT></TD>

            <TD headers="matches">A hexadecimal digit: <TT>[0-9a-fA-F]</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct posix"><TT>\p{Space}</TT></TD>

            <TD headers="matches">A whitespace character: <TT>[ \t\n\x0B\f\r]</TT></TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left" colspan="2">
              	<B> Classes for Unicode blocks&nbsp;and categories</B>
            </TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{InGreek}</TT></TD>

            <TD headers="matches">A character in the Greek&nbsp;block (simple block)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{Lu}</TT></TD>

            <TD headers="matches">An uppercase letter (simple category)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\p{Sc}</TT></TD>

            <TD headers="matches">A currency symbol</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode"><TT>\P{InGreek}</TT></TD>

            <TD headers="matches">Any character except one in the Greek block (negation)</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct unicode">
            <TT>[\p{L}&amp;&amp;[^\p{Lu}]]&nbsp;</TT></TD>

            <TD headers="matches">Any letter except an uppercase letter (subtraction)</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Boundary matchers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>^</TT></TD>

            <TD headers="matches">The beginning of a line</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>$</TT></TD>

            <TD headers="matches">The end of a line</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\b</TT></TD>

            <TD headers="matches">A word boundary</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\B</TT></TD>

            <TD headers="matches">A non-word boundary</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\A</TT></TD>

            <TD headers="matches">The beginning of the input</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\G</TT></TD>

            <TD headers="matches">The end of the previous match</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\Z</TT></TD>

            <TD headers="matches">The end of the input but for the final terminator,
            if&nbsp;any</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct bounds"><TT>\z</TT></TD>

            <TD headers="matches">The end of the input</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
			<TD align="left"><B>Greedy quantifiers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>?</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>*</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>+</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>{</TT><I>n</I><TT>}</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy"><I>X</I><TT>{</TT><I>n</I><TT>,}</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct greedy">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
            <TD align="left"><B>Reluctant quantifiers</B></TD>
  
            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>??</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>*?</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>+?</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>{</TT><I>n</I><TT>}?</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc"><I>X</I><TT>{</TT><I>n</I><TT>,}?</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct reluc">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}?</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          <TD align="left"><B>Possessive quantifiers</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>?+</TT></TD>

            <TD headers="matches"><I>X</I>, once or not at all</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>*+</TT></TD>

            <TD headers="matches"><I>X</I>, zero or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>++</TT></TD>

            <TD headers="matches"><I>X</I>, one or more times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>{</TT><I>n</I><TT>}+</TT></TD>

            <TD headers="matches"><I>X</I>, exactly <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss"><I>X</I><TT>{</TT><I>n</I><TT>,}+</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> times</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct poss">
            <I>X</I><TT>{</TT><I>n</I><TT>,</TT><I>m</I><TT>}+</TT></TD>

            <TD headers="matches"><I>X</I>, at least <I>n</I> but not more than <I>m</I> times</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          <TD align="left"><B>Logical operators</B></TD>
          
            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><I>XY</I></TD>

            <TD headers="matches"><I>X</I> followed by <I>Y</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><I>X</I><TT>|</TT><I>Y</I></TD>

            <TD headers="matches">Either <I>X</I> or <I>Y</I></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct logical"><TT>(</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches">X, as a capturing group</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Back references</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="bottom" headers="construct backref"><TT>\</TT><I>n</I></TD>

            <TD valign="bottom" headers="matches">Whatever the <I>n</I><SUP>th</SUP> capturing
            group matched</TD>
          </TR>

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left"><B>Quotation</B></TD>

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\</TT></TD>

            <TD headers="matches">Nothing, but quotes the following character</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\Q</TT></TD>

            <TD headers="matches">Nothing, but quotes all characters until <TT>\E</TT></TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct quot"><TT>\E</TT></TD>

            <TD headers="matches">Nothing, but ends quoting started by <TT>\Q</TT></TD>
          </TR><!-- Metachars: !$()*+.<>?[\]^{|} -->

          <TR>
            <TD>&nbsp;</TD>
            <TD>&nbsp;</TD>
          </TR>

          <TR align="left">
          	<TD align="left" colspan="2"><B>Special constructs&nbsp; (non-capturing)</B></TD>

            </TH>  

            <TD/>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?:</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, as a non-capturing group</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?idmsux-idmsux)&nbsp;</TT></TD>

            <TD headers="matches">Nothing, but turns match flags on - off</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special">
            <TT>(?idmsux-idmsux:</TT><I>X</I><TT>)</TT>&nbsp;&nbsp;</TD>

            <TD headers="matches"><I>X</I>, as a non-capturing group with the given flags on -
            off</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?=</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width positive lookahead</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?!</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width negative lookahead</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&lt;=</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width positive lookbehind</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&lt;!</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, via zero-width negative lookbehind</TD>
          </TR>

          <TR>
            <TD valign="top" headers="construct special"><TT>(?&gt;</TT><I>X</I><TT>)</TT></TD>

            <TD headers="matches"><I>X</I>, as an independent, non-capturing group</TD>
          </TR>
        </TBODY>
      </TABLE>
    </BLOCKQUOTE>

    <P class="relatedtopic">&nbsp;</P>

    <P class="relatedtopic">Related Topics</P>

    <UL>
      <LI>
        <P class="relatedtopic"><A href="Search_Memory.htm">Search Memory</A></P>
      </LI>
    </UL><BR>
  </BODY>
</HTML>
